<template>
	<view class="box">
		<!-- 顶部导航栏 -->
		<view class="upage__item">
			<view class="" @click="backFn">
				<u-icon name="arrow-left" color="#424242" size="24"></u-icon>
			</view>
			<view class="" style="font-size: 40rpx;color: #10181c;">
				配置北斗时间
			</view>
			<view class="" style="width: 240rpx;" @click="butBleFn">
				<u-button type="primary" shape="circle" :color="butcolor" :text="rightText"></u-button>
			</view>
		</view>

		<!-- 主要内容区域 -->
		<view class="home">
			<!-- 当前设备时间显示 -->
			<view class="time-display" v-if="currentTime">
				<view class="time-title">设备当前时间</view>
				<view class="time-value">{{ currentTime }}</view>
			</view>

			<!-- 从机地址查询 -->
			<view class="input_item">
				<view class="text">
					从机地址查询：
				</view>
				<view class="input">
					<u-button type="warning" shape="circle" size="mini" text="查询从机地址" @click="querySlaveAddress"
						:loading="queryAddressLoading"></u-button>
				</view>
			</view>

			<!-- 显示查询到的地址 -->
			<view class="input_item" v-if="queriedAddress">
				<view class="text">
					查询到的地址：
				</view>
				<view class="input">
					<u--input placeholder="查询到的地址" disabled border="bottom" v-model="queriedAddress"></u--input>
				</view>
			</view>

			<!-- 设备地址输入 -->
			<view class="input_item">
				<view class="text">
					设备地址：
				</view>
				<view class="input">
					<u--input placeholder="1-254" clearable type="digit" border="bottom"
						v-model="deviceAddress"></u--input>
				</view>
			</view>

			<!-- 日期时间选择 -->
			<view class="input_item">
				<view class="text">
					日期时间：
				</view>
				<view class="input" @click="openDateTimePicker">
					    <!-- 使用输入框触发日期选择器 -->
					    <view class="">
					    	选择日期时间
					    </view>

					<u-datetime-picker :value="datetimeValue" mode="datetime" :show="showPicker"
						@confirm="datetimeConfirm" @cancel="showPicker = false" :minDate="minDate" :maxDate="maxDate"
						:formatter="formatter"></u-datetime-picker>
				</view>
			</view>

			<!-- 时间预览 -->
			<view class="time-preview">
				<view class="preview-title">时间预览</view>
				<view class="preview-value">
					{{ previewTime.year }}年{{ previewTime.month }}月{{ previewTime.day }}日
					{{ previewTime.hour }}时{{ previewTime.minute }}分{{ previewTime.second }}秒
				</view>
			</view>

			<!-- 操作按钮区域 -->
			<u-button style="margin: 20rpx 0;" type="primary" shape="circle" text="查询设备时间" @click="queryTime"
				:loading="queryLoading"></u-button>

			<u-button style="margin: 20rpx 0;" type="success" shape="circle" text="设置设备时间" @click="setTime"
				:loading="setLoading"></u-button>

			<u-button style="margin: 20rpx 0;" type="warning" shape="circle" text="同步手机时间"
				@click="syncPhoneTime"></u-button>

			<!-- 消息提示组件 -->
			<u-toast ref="uToast"></u-toast>
		</view>
	</view>
</template>

<script>
	export default {
		data() {
			// 获取当前时间作为默认值
			const now = new Date();
			const year = now.getFullYear();
			const month = now.getMonth() + 1;
			const day = now.getDate();
			const hour = now.getHours();
			const minute = now.getMinutes();
			const second = now.getSeconds();

			return {
				showPicker: false,
				datetimeDisplay: '',
				butcolor: '#be3131', // 按钮颜色
				rightText: '未连接设备', // 按钮文本
				deviceAddress: '', // 设备地址
				queriedAddress: '', // 查询到的地址
				datetimeValue: Number(now), // 日期时间选择器值
				minDate: Number(new Date(2020, 0, 1)), // 最小日期
				maxDate: Number(new Date(2030, 11, 31)), // 最大日期
				previewTime: { // 时间预览对象
					year: year,
					month: month,
					day: day,
					hour: hour,
					minute: minute,
					second: second
				},
				currentTime: '', // 设备当前时间
				queryLoading: false, // 查询时间加载状态
				setLoading: false, // 设置时间加载状态
				queryAddressLoading: false, // 查询地址加载状态
				deviceId: '', // 蓝牙设备ID
				serviceId: '', // 蓝牙服务ID
				characteristicId: '', // 蓝牙特征值ID
				fff: '' // 蓝牙特征值
			}
		},
		onShow() {
			/**
			 * 页面显示时执行
			 * 1. 监听蓝牙连接状态
			 * 2. 获取蓝牙服务
			 */
			console.log('页面显示，初始化蓝牙连接');

			// 监听蓝牙连接状态变化
			uni.onBLEConnectionStateChange((res) => {
				console.log('蓝牙连接状态变化:', res);
				// 如果连接断开，重置状态并返回上一页
				if (res.connected !== true) {
					this.butcolor = '#be3131';
					this.rightText = '未连接设备';
					uni.$u.vuex('vuex_devicename', '');
					uni.$u.vuex('vuex_deviceId', '');
					this.$refs.uToast.show({
						type: 'error',
						icon: false,
						message: "蓝牙连接已断开",
						position: 'top'
					});
					uni.navigateBack({
						delta: 2
					});
				}
			});

			// 显示加载提示
			uni.showLoading({
				title: '加载中',
				mask: true
			});
			setTimeout(() => {
				uni.hideLoading();
			}, 0);

			// 获取设备ID并初始化蓝牙服务
			this.deviceId = this.vuex_deviceId;
			console.log('设备ID:', this.deviceId);
			this.getBLEDeviceServices();
		},
		onUnload() {
			/**
			 * 页面卸载时清理资源
			 */
			console.log('页面卸载，清理资源');
		},
		methods: {
			/**
			 * 返回上一页
			 */
			backFn() {
				console.log('返回上一页');
				uni.navigateBack({
					delta: 1
				});
			},

			/**
			 * 蓝牙按钮点击事件
			 * 处理蓝牙连接/断开逻辑
			 */
			butBleFn() {
				console.log('蓝牙按钮点击');
				if (this.rightText === '设备已连接') {
					// 断开连接
					this.disconnectBLE();
				} else {
					// 跳转到蓝牙连接页面
					uni.navigateTo({
						url: '/pages/index/BLE'
					});
				}
			},

			/**
			 * 断开蓝牙连接
			 */
			disconnectBLE() {
				console.log('断开蓝牙连接');
				uni.closeBLEConnection({
					deviceId: this.vuex_deviceId,
					success: (res) => {
						console.log('蓝牙断开成功');
						this.butcolor = '#be3131';
						this.rightText = '未连接设备';
						uni.$u.vuex('vuex_devicename', '');
						uni.$u.vuex('vuex_deviceId', '');
						this.$refs.uToast.show({
							type: 'success',
							icon: false,
							message: "蓝牙已断开",
							position: 'top'
						});
					},
					fail: (err) => {
						console.log('蓝牙断开失败:', err);
						this.$refs.uToast.show({
							type: 'error',
							icon: false,
							message: "蓝牙断开失败",
							position: 'top'
						});
					}
				});
			},

			openDateTimePicker() {
				console.log('时间');
				this.showPicker = true;
			},

			datetimeConfirm(e) {
				this.datetimeValue = e.value;
				const date = new Date(e.value);

				// 更新显示
				this.datetimeDisplay = this.formatDateTime(date);

				// 更新预览时间
				this.previewTime = {
					year: date.getFullYear(),
					month: date.getMonth() + 1,
					day: date.getDate(),
					hour: date.getHours(),
					minute: date.getMinutes(),
					second: date.getSeconds()
				};

				this.showPicker = false;
			},

			formatDateTime(date) {
				return `${date.getFullYear()}年${date.getMonth() + 1}月${date.getDate()}日 ${date.getHours()}时${date.getMinutes()}分`;
			},

			// 自定义格式化（可选）
			formatter(type, value) {
				if (type === 'year') {
					return `${value}年`;
				}
				if (type === 'month') {
					return `${value}月`;
				}
				if (type === 'day') {
					return `${value}日`;
				}
				if (type === 'hour') {
					return `${value}时`;
				}
				if (type === 'minute') {
					return `${value}分`;
				}
				return value;
			},

			/**
			 * 同步手机时间
			 * 将当前手机时间同步到时间选择器
			 */
			syncPhoneTime() {
				console.log('同步手机时间');
				const now = new Date();
				// 更新日期时间选择器值
				this.datetimeValue = Number(now);
				// 更新预览时间
				this.previewTime = {
					year: now.getFullYear(),
					month: now.getMonth() + 1,
					day: now.getDate(),
					hour: now.getHours(),
					minute: now.getMinutes(),
					second: now.getSeconds()
				};
				// 显示成功提示
				this.$refs.uToast.show({
					type: 'success',
					icon: false,
					message: "已同步手机时间",
					position: 'top'
				});
				console.log('同步后的时间:', this.previewTime);
			},

			/**
			 * 查询从机地址
			 * 发送广播查询从机设备地址
			 * 主机发送：00 03 ff 02 00 01 14 0F
			 * 从机返回: 00 03 02 00 02 04 45(表示雨量站地址为 2)
			 */
			querySlaveAddress() {
				console.log('开始查询从机地址');
				this.queryAddressLoading = true;

				// 构建查询从机地址指令
				// 格式：00 03 ff 02 00 01 CRC
				let msg = ['00', '03', 'ff', '02', '00', '01'];
				let msgStr = msg.join('');
				let crc = this.crc16(msgStr);
				let fullMsg = msgStr + crc[1] + crc[0];

				let arr = this.chunkStringByTwo(fullMsg).map(i => '0x' + i);
				console.log('查询从机地址指令:', arr);

				// 发送指令
				this.conbuffer(arr);

				// 2秒后重置加载状态
				setTimeout(() => {
					this.queryAddressLoading = false;
				}, 2000);
			},

			/**
			 * 解析从机地址返回数据
			 * @param {string} hexData - 16进制返回数据
			 * 返回格式: 00 03 02 00 02 04 45(表示雨量站地址为 2)
			 */
			parseSlaveAddressResponse(hexData) {
				// 检查数据长度是否足够
				if (hexData.length < 14) {
					console.log('从机地址返回数据长度不足:', hexData);
					return null;
				}

				/**
				 * 返回帧结构：
				 * 00 - 从机地址
				 * 03 - 功能码
				 * 02 - 数据长度（2字节）
				 * 00 02 - 返回的地址数据（16进制，2个字节）
				 * 04 45 - CRC校验
				 */
				// 提取地址数据部分 (第6-9位，共4个字符，2个字节)
				let addressHex = hexData.substr(6, 4); // 获取 "0002"
				// 将16进制地址转换为10进制
				let address = this.hexToDecimal(addressHex);

				console.log('解析到从机地址:', address, '原始数据:', addressHex);
				return address;
			},

			/**
			 * 查询设备时间
			 * 发送帧：01 03 ff 08 00 03 B4 1D
			 */
			queryTime() {
				console.log('开始查询设备时间');
				// 验证设备地址
				if (!this.validateAddress()) return;

				this.queryLoading = true;

				// 构建查询时间指令
				// 格式：地址 03 ff 08 00 03 CRC
				let addressHex = this.decimalToHex(parseInt(this.deviceAddress));
				let msg = [addressHex, '03', 'ff', '08', '00', '03'];
				let msgStr = msg.join('');
				let crc = this.crc16(msgStr);
				let fullMsg = msgStr + crc[1] + crc[0];

				let arr = this.chunkStringByTwo(fullMsg).map(i => '0x' + i);
				console.log('查询时间指令:', arr);

				// 发送指令
				this.conbuffer(arr);

				// 2秒后重置加载状态
				setTimeout(() => {
					this.queryLoading = false;
				}, 2000);
			},

			/**
			 * 设置设备时间
			 * 发送帧：01 10 ff 08 00 03 06 25 09 01 22 09 10 29 23
			 * 时间设定后，设备将重启
			 */
			setTime() {
			    console.log('开始设置设备时间');
			    // 验证设备地址
			    // if (!this.validateAddress()) return;
			    
			    this.setLoading = true;
			    
			    // 构建设置时间指令
			    // 格式：地址 10 ff 08 00 03 06 年 月 日 时 分 秒 CRC
			    let addressHex = this.decimalToHex(parseInt(this.deviceAddress));
			    
			    // 直接使用BCD码格式，不需要转换
			    // 年份使用后两位（如2025年表示为25）
			    let year = this.previewTime.year - 2000;  // 2025 → 25
			    let month = this.previewTime.month;       // 9 → 9
			    let day = this.previewTime.day;           // 21 → 21
			    let hour = this.previewTime.hour;         // 21 → 21
			    let minute = this.previewTime.minute;     // 59 → 59
			    let second = this.previewTime.second;     // 26 → 26
			    
			    // 将十进制转换为BCD码格式的16进制字符串
			    let yearHex = this.decimalToBCD(year);
			    let monthHex = this.decimalToBCD(month);
			    let dayHex = this.decimalToBCD(day);
			    let hourHex = this.decimalToBCD(hour);
			    let minuteHex = this.decimalToBCD(minute);
			    let secondHex = this.decimalToBCD(second);
			    
			    // 构建完整指令
			    let msg = [
			        addressHex, '10', 'ff', '08', '00', '03', '06',
			        yearHex, monthHex, dayHex, hourHex, minuteHex, secondHex
			    ];
			    
			    let msgStr = msg.join('');
			    let crc = this.crc16(msgStr);
			    let fullMsg = msgStr + crc[1] + crc[0];
			    
			    let arr = this.chunkStringByTwo(fullMsg).map(i => '0x' + i);
			    console.log('设置时间指令:', arr);
			    console.log('设置的时间:', this.previewTime);
			    console.log('BCD码数据:', {yearHex, monthHex, dayHex, hourHex, minuteHex, secondHex});
			    
			    // 发送指令
			    this.conbuffer(arr);
			    
			    // 2秒后重置加载状态
			    setTimeout(() => {
			        this.setLoading = false;
			    }, 2000);
			},
			
			/**
			 * 十进制转BCD码（16进制字符串）
			 * @param {number} decimal - 十进制数字
			 * @returns {string} BCD码的16进制字符串
			 */
			decimalToBCD(decimal) {
			    // BCD码：十位在高4位，个位在低4位
			    let bcd = ((Math.floor(decimal / 10) << 4) | (decimal % 10));
			    return bcd.toString(16).toUpperCase().padStart(2, '0');
			},

			/**
			 * 解析北斗设备时间返回数据
			 * @param {string} hexData - 16进制返回数据
			 * @returns {string} 格式化时间
			 */
			parseTimeResponse(hexData) {
				if (hexData.length < 18) return null;

				// BCD码解析：每个字节的高4位和低4位分别代表十位和个位
				let year = 2000 + (parseInt(hexData[6], 16) * 10 + parseInt(hexData[7], 16));
				let month = parseInt(hexData[8], 16) * 10 + parseInt(hexData[9], 16);
				let day = parseInt(hexData[10], 16) * 10 + parseInt(hexData[11], 16);
				let hour = parseInt(hexData[12], 16) * 10 + parseInt(hexData[13], 16);
				let minute = parseInt(hexData[14], 16) * 10 + parseInt(hexData[15], 16);
				let second = parseInt(hexData[16], 16) * 10 + parseInt(hexData[17], 16);

				return `${year}年${month}月${day}日 ${hour}时${minute}分${second}秒`;
			},

			/**
			 * 验证设备地址格式
			 * @returns {boolean} 验证结果
			 */
			validateAddress() {
				if (!this.deviceAddress || this.deviceAddress < 1 || this.deviceAddress > 254) {
					this.$refs.uToast.show({
						type: 'error',
						icon: false,
						message: "设备地址格式不正确(1-254)",
						position: 'top'
					});
					return false;
				}
				return true;
			},

			/**
			 * 监听蓝牙特征值变化
			 * 处理设备返回的数据
			 */
			listenValueChange() {
				console.log('开始监听蓝牙特征值变化');
				setTimeout(() => {
					uni.onBLECharacteristicValueChange(res => {
						let resHex = this.ab2hex(res.value);
						console.log('蓝牙返回数据:', resHex, '长度:', resHex.length);

						// 处理从机地址查询返回
						if (resHex.length === 14) {
							console.log('收到从机地址查询返回');
							let address = this.parseSlaveAddressResponse(resHex);
							if (address) {
								this.deviceAddress = address.toString();
								this.queriedAddress = address.toString();
								this.$refs.uToast.show({
									type: 'success',
									icon: false,
									message: `查询到从机地址: ${address}`,
									position: 'top'
								});
							} else {
								this.$refs.uToast.show({
									type: 'error',
									icon: false,
									message: "从机地址解析失败",
									position: 'top'
								});
							}
						}

						// 处理时间查询返回
						if (resHex.length === 22) {
							console.log('收到时间查询返回');
							let timeStr = this.parseTimeResponse(resHex);
							if (timeStr) {
								this.currentTime = timeStr;
								this.$refs.uToast.show({
									type: 'success',
									icon: false,
									message: "时间查询成功",
									position: 'top'
								});
							} else {
								this.$refs.uToast.show({
									type: 'error',
									icon: false,
									message: "时间解析失败",
									position: 'top'
								});
							}
						}

						// 处理时间设置返回
						if (resHex.length === 16) {
							console.log('收到时间设置返回');
							this.$refs.uToast.show({
								type: 'success',
								icon: false,
								message: "时间设置成功，设备将重启",
								position: 'top'
							});
						}
					});
				}, 300);
			},

			// =============== 工具方法 ===============

			/**
			 * 将字符串按2个字符一组分割
			 * @param {string} str - 要分割的字符串
			 * @returns {Array} 分割后的数组
			 */
			chunkStringByTwo(str) {
				const result = [];
				for (let i = 0; i < str.length; i += 2) {
					result.push(str.slice(i, i + 2));
				}
				return result;
			},

			/**
			 * CRC16校验算法
			 * @param {string} dataHexString - 16进制字符串
			 * @returns {Array} CRC校验码数组
			 */
			crc16(dataHexString) {
				const dataBytes = [];
				// 将16进制字符串转换为字节数组
				for (let i = 0; i < dataHexString.length; i += 2) {
					dataBytes.push(parseInt(dataHexString.substr(i, 2), 16));
				}

				let crc = 0xFFFF;
				const polynomial = 0xA001;

				// 计算CRC值
				for (const byte of dataBytes) {
					crc ^= byte;
					for (let i = 0; i < 8; i++) {
						if (crc & 0x0001) {
							crc = ((crc >> 1) ^ polynomial) & 0xFFFF;
						} else {
							crc >>= 1;
						}
					}
				}

				// 将CRC值转换为16进制字符串
				let crcstr = crc.toString(16).toUpperCase();
				// 处理奇数字节情况，前面补0
				if (crcstr.length % 2 == 0) {
					let result = crcstr.match(/.{1,2}/g);
					return result;
				} else {
					let str = '0' + crcstr;
					let result = str.match(/.{1,2}/g);
					return result;
				}
			},

			/**
			 * 16进制转10进制
			 * @param {string} hex - 16进制字符串
			 * @returns {number} 10进制数字
			 */
			hexToDecimal(hex) {
				return parseInt(hex, 16);
			},

			/**
			 * 10进制转16进制
			 * @param {number} decimal - 10进制数字
			 * @returns {string} 16进制字符串
			 */
			decimalToHex(decimal) {
				let hex = decimal.toString(16).toUpperCase();
				// 处理单数字节，前面补0
				if (hex.length % 2 !== 0) {
					return '0' + hex;
				} else {
					return hex;
				}
			},

			/**
			 * ArrayBuffer转16进制字符串
			 * @param {ArrayBuffer} buffer - ArrayBuffer对象
			 * @returns {string} 16进制字符串
			 */
			ab2hex(buffer) {
				const hexArr = Array.prototype.map.call(
					new Uint8Array(buffer),
					function(bit) {
						return ('00' + bit.toString(16)).slice(-2);
					}
				);
				return hexArr.join('');
			},

			/**
			 * 将16进制数组转换为ArrayBuffer并发送
			 * @param {Array} data - 16进制数据数组
			 */
			conbuffer(data) {
				let msg = data;
				console.log('发送数据:', msg);
				// 创建ArrayBuffer
				const buffer = new ArrayBuffer(msg.length);
				const dataView = new DataView(buffer);
				// 将16进制数据写入ArrayBuffer
				for (var i = 0; i < msg.length; i++) {
					dataView.setUint8(i, msg[i]);
				}
				// 发送数据
				this.sendMsgToKey(buffer);
			},

			/**
			 * 向蓝牙设备发送数据（分包发送）
			 * @param {ArrayBuffer} buffer - 要发送的数据缓冲区
			 */
			sendMsgToKey(buffer) {
				var that = this;
				const packageSize = 20; // 分包大小

				// 如果数据长度小于等于20字节，直接发送
				if (buffer.byteLength <= 20) {
					uni.writeBLECharacteristicValue({
						deviceId: that.deviceId,
						serviceId: that.serviceId,
						characteristicId: that.fff,
						value: buffer,
						writeType: 'write',
						success: (res) => {
							console.log('指令发送成功');
						},
						fail: (err) => {
							console.log('传输失败', err);
							this.$refs.uToast.show({
								type: 'error',
								icon: false,
								message: "指令发送失败",
								position: 'top'
							});
						}
					});
				} else {
					// 数据长度大于20字节，需要分包发送
					var newData = buffer.slice(20);
					var writeBuffer = buffer.slice(0, 20);
					uni.writeBLECharacteristicValue({
						deviceId: that.deviceId,
						serviceId: that.serviceId,
						characteristicId: that.fff,
						value: writeBuffer,
						writeType: 'write',
						success: function(res) {
							console.log('分包发送成功，继续发送剩余数据');
							// 递归发送剩余数据
							setTimeout(() => {
								that.sendMsgToKey(newData);
							}, 100);
						},
						fail: (err) => {
							console.log('分包传输失败', err);
							this.$refs.uToast.show({
								type: 'error',
								icon: false,
								message: "数据发送失败",
								position: 'top'
							});
						}
					});
				}
			},

			// =============== 蓝牙服务相关方法 ===============

			/**
			 * 获取蓝牙设备服务
			 */
			getBLEDeviceServices() {
				console.log('开始获取蓝牙设备服务');
				setTimeout(() => {
					uni.getBLEDeviceServices({
						deviceId: this.vuex_deviceId,
						success: (res) => {
							console.log('获取蓝牙所有服务成功:', res.services);
							let foundService = false;
							// 遍历服务，查找匹配的服务UUID
							res.services.forEach((item) => {
								if (item.uuid.indexOf("0000FFF0") != -1 || item.uuid.indexOf(
										"0000FFE0") != -1) {
									this.serviceId = item.uuid;
									foundService = true;
									console.log('找到匹配的服务:', item.uuid);
									// 获取服务特征值
									this.getBLEDeviceCharacteristics();
								}
							});
							if (!foundService) {
								console.log('未找到匹配的蓝牙服务');
								uni.hideLoading();
								this.$refs.uToast.show({
									type: 'error',
									icon: false,
									message: "未找到匹配的蓝牙服务",
									position: 'top'
								});
							}
						},
						fail: (err) => {
							console.log('获取蓝牙服务失败:', err);
							uni.hideLoading();
							this.$refs.uToast.show({
								type: 'error',
								icon: false,
								message: "获取蓝牙服务失败",
								position: 'top'
							});
						}
					});
				}, 1000);
			},

			/**
			 * 获取蓝牙服务特征值
			 */
			getBLEDeviceCharacteristics() {
				console.log('开始获取蓝牙服务特征值');
				setTimeout(() => {
					uni.getBLEDeviceCharacteristics({
						deviceId: this.deviceId,
						serviceId: this.serviceId,
						success: (res) => {
							console.log('获取特征值成功:', res.characteristics);
							let foundWriteChar = false;
							let foundNotifyChar = false;

							// 遍历特征值，查找匹配的特征UUID
							res.characteristics.forEach((item) => {
								// 查找写入特征值
								if (item.uuid.indexOf("FFF2") != -1 || item.uuid.indexOf(
										"FFE1") != -1) {
									this.fff = item.uuid;
									foundWriteChar = true;
									console.log('找到写入特征值:', item.uuid);
								}
								// 查找通知特征值
								if (item.uuid.indexOf("0000FFE1") != -1 || item.uuid.indexOf(
										"0000FFF1") != -1) {
									this.characteristicId = item.uuid;
									foundNotifyChar = true;
									console.log('找到通知特征值:', item.uuid);
									// 启用特征值通知
									this.notifyBLECharacteristicValueChange(item.uuid);
								}
							});

							if (!foundWriteChar) {
								console.log('未找到写入特征值');
							}
							if (!foundNotifyChar) {
								console.log('未找到通知特征值');
								uni.hideLoading();
								this.$refs.uToast.show({
									type: 'error',
									icon: false,
									message: "未找到通知特征值",
									position: 'top'
								});
							}
						},
						fail: (err) => {
							console.log('获取特征值失败:', err);
							uni.hideLoading();
							this.$refs.uToast.show({
								type: 'error',
								icon: false,
								message: "获取特征值失败",
								position: 'top'
							});
						}
					});
				}, 1000);
			},

			/**
			 * 启用蓝牙特征值通知
			 * @param {string} characteristicId - 特征值ID
			 */
			notifyBLECharacteristicValueChange(characteristicId) {
				console.log('启用蓝牙特征值通知:', characteristicId);
				uni.notifyBLECharacteristicValueChange({
					state: true, // 启用通知
					deviceId: this.deviceId,
					serviceId: this.serviceId,
					characteristicId: this.characteristicId,
					success: (res) => {
						// 连接成功处理
						console.log('蓝牙特征值通知启用成功');
						uni.hideLoading();
						this.listenValueChange();
						this.butcolor = '#00aa7f';
						this.rightText = '设备已连接';
						this.$refs.uToast.show({
							type: 'success',
							icon: false,
							message: "蓝牙连接成功",
							position: 'top'
						});
						setTimeout(() => {
							this.querySlaveAddress()
						}, 500)
					},
					fail: (res) => {
						// 连接失败处理
						console.log('蓝牙特征值通知启用失败:', res);
						uni.hideLoading();
						this.$refs.uToast.show({
							type: 'error',
							icon: false,
							message: "蓝牙服务连接失败",
							position: 'top'
						});
					}
				});
			}
		}
	}
</script>

<style scoped lang="scss">
	.box {
		.upage__item {
			margin-top: 80rpx;
			padding: 0 30rpx 10rpx 30rpx;
			display: flex;
			align-items: center;
			justify-content: space-between;
		}

		.home {
			padding: 30rpx;
			border-radius: 30rpx;

			/* 设备当前时间显示样式 */
			.time-display {
				background: #f0f9ff;
				border-radius: 20rpx;
				padding: 30rpx;
				margin-bottom: 30rpx;
				text-align: center;
				border: 2rpx solid #bee3f8;

				.time-title {
					font-size: 28rpx;
					color: #2b6cb0;
					margin-bottom: 15rpx;
				}

				.time-value {
					font-size: 32rpx;
					font-weight: bold;
					color: #2c5282;
				}
			}

			/* 时间预览样式 */
			.time-preview {
				background: #f0fff4;
				border-radius: 20rpx;
				padding: 30rpx;
				margin: 20rpx 0;
				text-align: center;
				border: 2rpx solid #c6f6d5;

				.preview-title {
					font-size: 28rpx;
					color: #276749;
					margin-bottom: 15rpx;
				}

				.preview-value {
					font-size: 30rpx;
					color: #2f855a;
				}
			}

			/* 输入项样式 */
			.input_item {
				display: flex;
				justify-content: space-between;
				align-items: center;
				padding: 5rpx 10rpx;
				margin-bottom: 15rpx;
				border-radius: 20rpx;
				border: 5rpx solid #fff;
				background-color: #ffffff;

				.text {
					color: #000000;
					text-align: justify;
					text-align-last: justify;
					padding: 15rpx;
					border-radius: 10rpx;
					width: 250rpx;
				}

				.input {
					width: 320rpx;
				}
			}
		}
	}
</style>

<style>
	page {
		background-color: #f2f1f6;
	}
</style>